﻿#region Using directives

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Configuration.Provider;
using System.Web.Configuration;
using System.Web;
using BesAsm.MasterData.Entities;
using BesAsm.MasterData.Data;
using BesAsm.MasterData.Data.Bases;

#endregion

namespace BesAsm.MasterData.Data
{
	/// <summary>
	/// This class represents the Data source repository and gives access to all the underlying providers.
	/// </summary>
	[CLSCompliant(true)]
	public sealed class DataRepository 
	{
		private static volatile NetTiersProvider _provider = null;
        private static volatile NetTiersProviderCollection _providers = null;
		private static volatile NetTiersServiceSection _section = null;
        
        private static object SyncRoot = new object();
				
		private DataRepository()
		{
		}
		
		#region Public LoadProvider
		/// <summary>
        /// Enables the DataRepository to programatically create and 
        /// pass in a <c>NetTiersProvider</c> during runtime.
        /// </summary>
        /// <param name="provider">An instatiated NetTiersProvider.</param>
        public static void LoadProvider(NetTiersProvider provider)
        {
			LoadProvider(provider, false);
        }
		
		/// <summary>
        /// Enables the DataRepository to programatically create and 
        /// pass in a <c>NetTiersProvider</c> during runtime.
        /// </summary>
        /// <param name="provider">An instatiated NetTiersProvider.</param>
        /// <param name="setAsDefault">ability to set any valid provider as the default provider for the DataRepository.</param>
		public static void LoadProvider(NetTiersProvider provider, bool setAsDefault)
        {
            if (provider == null)
                throw new ArgumentNullException("provider");

            if (_providers == null)
			{
				lock(SyncRoot)
				{
            		if (_providers == null)
						_providers = new NetTiersProviderCollection();
				}
			}
			
            if (_providers[provider.Name] == null)
            {
                lock (_providers.SyncRoot)
                {
                    _providers.Add(provider);
                }
            }

            if (_provider == null || setAsDefault)
            {
                lock (SyncRoot)
                {
                    if(_provider == null || setAsDefault)
                         _provider = provider;
                }
            }
        }
		#endregion 
		
		///<summary>
		/// Configuration based provider loading, will load the providers on first call.
		///</summary>
		private static void LoadProviders()
        {
            // Avoid claiming lock if providers are already loaded
            if (_provider == null)
            {
                lock (SyncRoot)
                {
                    // Do this again to make sure _provider is still null
                    if (_provider == null)
                    {
                        // Load registered providers and point _provider to the default provider
                        _providers = new NetTiersProviderCollection();

                        ProvidersHelper.InstantiateProviders(NetTiersSection.Providers, _providers, typeof(NetTiersProvider));
						_provider = _providers[NetTiersSection.DefaultProvider];

                        if (_provider == null)
                        {
                            throw new ProviderException("Unable to load default NetTiersProvider");
                        }
                    }
                }
            }
        }

		/// <summary>
        /// Gets the provider.
        /// </summary>
        /// <value>The provider.</value>
        public static NetTiersProvider Provider
        {
            get { LoadProviders(); return _provider; }
        }

		/// <summary>
        /// Gets the provider collection.
        /// </summary>
        /// <value>The providers.</value>
        public static NetTiersProviderCollection Providers
        {
            get { LoadProviders(); return _providers; }
        }
		
		/// <summary>
		/// Creates a new <see cref="TransactionManager"/> instance from the current datasource.
		/// </summary>
		/// <returns></returns>
		public TransactionManager CreateTransaction()
		{
			return _provider.CreateTransaction();
		}

		#region Configuration

		/// <summary>
		/// Gets a reference to the configured NetTiersServiceSection object.
		/// </summary>
		public static NetTiersServiceSection NetTiersSection
		{
			get
			{
				// Try to get a reference to the default <netTiersService> section
				_section = WebConfigurationManager.GetSection("netTiersService") as NetTiersServiceSection;

				if ( _section == null )
				{
					// otherwise look for section based on the assembly name
					_section = WebConfigurationManager.GetSection("BesAsm.MasterData.Data") as NetTiersServiceSection;
				}

				if ( _section == null )
				{
					throw new ProviderException("Unable to load NetTiersServiceSection");
				}

				return _section;
			}
		}

		#endregion Configuration

		#region Connections

		/// <summary>
		/// Gets a reference to the ConnectionStringSettings collection.
		/// </summary>
		public static ConnectionStringSettingsCollection ConnectionStrings
		{
			get
			{
					return WebConfigurationManager.ConnectionStrings;
			}
		}

		// dictionary of connection providers
		private static Dictionary<String, ConnectionProvider> _connections;

		/// <summary>
		/// Gets the dictionary of connection providers.
		/// </summary>
		public static Dictionary<String, ConnectionProvider> Connections
		{
			get
			{
				if ( _connections == null )
				{
					lock (SyncRoot)
                	{
						if (_connections == null)
						{
							_connections = new Dictionary<String, ConnectionProvider>();
		
							// add a connection provider for each configured connection string
							foreach ( ConnectionStringSettings conn in ConnectionStrings )
							{
								_connections.Add(conn.Name, new ConnectionProvider(conn.Name, conn.ConnectionString));
							}
						}
					}
				}

				return _connections;
			}
		}

		/// <summary>
		/// Adds the specified connection string to the map of connection strings.
		/// </summary>
		/// <param name="connectionStringName">The connection string name.</param>
		/// <param name="connectionString">The provider specific connection information.</param>
		public static void AddConnection(String connectionStringName, String connectionString)
		{
			lock (SyncRoot)
            {
				Connections.Remove(connectionStringName);
				ConnectionProvider connection = new ConnectionProvider(connectionStringName, connectionString);
				Connections.Add(connectionStringName, connection);
			}
		}

		/// <summary>
		/// Provides ability to switch connection string at runtime.
		/// </summary>
		public sealed class ConnectionProvider
		{
			private NetTiersProvider _provider;
			private NetTiersProviderCollection _providers;
			private String _connectionStringName;
			private String _connectionString;


			/// <summary>
			/// Initializes a new instance of the ConnectionProvider class.
			/// </summary>
			/// <param name="connectionStringName">The connection string name.</param>
			/// <param name="connectionString">The provider specific connection information.</param>
			public ConnectionProvider(String connectionStringName, String connectionString)
			{
				_connectionString = connectionString;
				_connectionStringName = connectionStringName;
			}

			/// <summary>
			/// Gets the provider.
			/// </summary>
			public NetTiersProvider Provider
			{
				get { LoadProviders(); return _provider; }
			}

			/// <summary>
			/// Gets the provider collection.
			/// </summary>
			public NetTiersProviderCollection Providers
			{
				get { LoadProviders(); return _providers; }
			}

			/// <summary>
			/// Instantiates the configured providers based on the supplied connection string.
			/// </summary>
			private void LoadProviders()
			{
				DataRepository.LoadProviders();

				// Avoid claiming lock if providers are already loaded
				if ( _providers == null )
				{
					lock ( SyncRoot )
					{
						// Do this again to make sure _provider is still null
						if ( _providers == null )
						{
							// apply connection information to each provider
							for ( int i = 0; i < NetTiersSection.Providers.Count; i++ )
							{
								NetTiersSection.Providers[i].Parameters["connectionStringName"] = _connectionStringName;
								// remove previous connection string, if any
								NetTiersSection.Providers[i].Parameters.Remove("connectionString");

								if ( !String.IsNullOrEmpty(_connectionString) )
								{
									NetTiersSection.Providers[i].Parameters["connectionString"] = _connectionString;
								}
							}

							// Load registered providers and point _provider to the default provider
							_providers = new NetTiersProviderCollection();

							ProvidersHelper.InstantiateProviders(NetTiersSection.Providers, _providers, typeof(NetTiersProvider));
							_provider = _providers[NetTiersSection.DefaultProvider];
						}
					}
				}
			}
		}

		#endregion Connections

		#region Static properties
		
		#region OrificeTypeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="OrificeType"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static OrificeTypeProviderBase OrificeTypeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.OrificeTypeProvider;
			}
		}
		
		#endregion
		
		#region PipeShapeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PipeShape"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PipeShapeProviderBase PipeShapeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PipeShapeProvider;
			}
		}
		
		#endregion
		
		#region StreetTargetTypeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="StreetTargetType"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static StreetTargetTypeProviderBase StreetTargetTypeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.StreetTargetTypeProvider;
			}
		}
		
		#endregion
		
		#region ZoneProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Zone"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ZoneProviderBase ZoneProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ZoneProvider;
			}
		}
		
		#endregion
		
		#region StatusProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Status"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static StatusProviderBase StatusProvider
		{
			get 
			{
				LoadProviders();
				return _provider.StatusProvider;
			}
		}
		
		#endregion
		
		#region LinkTypeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="LinkType"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static LinkTypeProviderBase LinkTypeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.LinkTypeProvider;
			}
		}
		
		#endregion
		
		#region SscProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Ssc"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SscProviderBase SscProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SscProvider;
			}
		}
		
		#endregion
		
		#region PipeFlowTypeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PipeFlowType"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PipeFlowTypeProviderBase PipeFlowTypeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PipeFlowTypeProvider;
			}
		}
		
		#endregion
		
		#region WeirTypeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="WeirType"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static WeirTypeProviderBase WeirTypeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.WeirTypeProvider;
			}
		}
		
		#endregion
		
		#region SpecialLinkDatumProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SpecialLinkDatum"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SpecialLinkDatumProviderBase SpecialLinkDatumProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SpecialLinkDatumProvider;
			}
		}
		
		#endregion
		
		#region SpecialLinkTypeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SpecialLinkType"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SpecialLinkTypeProviderBase SpecialLinkTypeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SpecialLinkTypeProvider;
			}
		}
		
		#endregion
		
		#region RoofTargetProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="RoofTarget"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static RoofTargetProviderBase RoofTargetProvider
		{
			get 
			{
				LoadProviders();
				return _provider.RoofTargetProvider;
			}
		}
		
		#endregion
		
		#region DscProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Dsc"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static DscProviderBase DscProvider
		{
			get 
			{
				LoadProviders();
				return _provider.DscProvider;
			}
		}
		
		#endregion
		
		#region SewerabilityProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Sewerability"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SewerabilityProviderBase SewerabilityProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SewerabilityProvider;
			}
		}
		
		#endregion
		
		#region PumpCurveProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PumpCurve"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PumpCurveProviderBase PumpCurveProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PumpCurveProvider;
			}
		}
		
		#endregion
		
		#region SpecialLinkProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SpecialLink"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SpecialLinkProviderBase SpecialLinkProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SpecialLinkProvider;
			}
		}
		
		#endregion
		
		#region SanPatternProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SanPattern"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SanPatternProviderBase SanPatternProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SanPatternProvider;
			}
		}
		
		#endregion
		
		#region StormTypeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="StormType"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static StormTypeProviderBase StormTypeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.StormTypeProvider;
			}
		}
		
		#endregion
		
		#region TimeFrameProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="TimeFrame"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static TimeFrameProviderBase TimeFrameProvider
		{
			get 
			{
				LoadProviders();
				return _provider.TimeFrameProvider;
			}
		}
		
		#endregion
		
		#region NodeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Node"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NodeProviderBase NodeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NodeProvider;
			}
		}
		
		#endregion
		
		#region StormProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Storm"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static StormProviderBase StormProvider
		{
			get 
			{
				LoadProviders();
				return _provider.StormProvider;
			}
		}
		
		#endregion
		
		#region WeirProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Weir"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static WeirProviderBase WeirProvider
		{
			get 
			{
				LoadProviders();
				return _provider.WeirProvider;
			}
		}
		
		#endregion
		
		#region AsmZoningProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="AsmZoning"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static AsmZoningProviderBase AsmZoningProvider
		{
			get 
			{
				LoadProviders();
				return _provider.AsmZoningProvider;
			}
		}
		
		#endregion
		
		#region DataSourceProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="DataSource"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static DataSourceProviderBase DataSourceProvider
		{
			get 
			{
				LoadProviders();
				return _provider.DataSourceProvider;
			}
		}
		
		#endregion
		
		#region AssumptionCodeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="AssumptionCode"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static AssumptionCodeProviderBase AssumptionCodeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.AssumptionCodeProvider;
			}
		}
		
		#endregion
		
		#region HansenServiceCodeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="HansenServiceCode"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static HansenServiceCodeProviderBase HansenServiceCodeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.HansenServiceCodeProvider;
			}
		}
		
		#endregion
		
		#region NodeTypeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="NodeType"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NodeTypeProviderBase NodeTypeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NodeTypeProvider;
			}
		}
		
		#endregion
		
		#region MaterialProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Material"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static MaterialProviderBase MaterialProvider
		{
			get 
			{
				LoadProviders();
				return _provider.MaterialProvider;
			}
		}
		
		#endregion
		
		#region DiscoClassProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="DiscoClass"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static DiscoClassProviderBase DiscoClassProvider
		{
			get 
			{
				LoadProviders();
				return _provider.DiscoClassProvider;
			}
		}
		
		#endregion
		
		#region StreetTargetProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="StreetTarget"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static StreetTargetProviderBase StreetTargetProvider
		{
			get 
			{
				LoadProviders();
				return _provider.StreetTargetProvider;
			}
		}
		
		#endregion
		
		#region ImperviousTypeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ImperviousType"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ImperviousTypeProviderBase ImperviousTypeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ImperviousTypeProvider;
			}
		}
		
		#endregion
		
		#region DetailedZoneProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="DetailedZone"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static DetailedZoneProviderBase DetailedZoneProvider
		{
			get 
			{
				LoadProviders();
				return _provider.DetailedZoneProvider;
			}
		}
		
		#endregion
		
		#region LinkProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Link"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static LinkProviderBase LinkProvider
		{
			get 
			{
				LoadProviders();
				return _provider.LinkProvider;
			}
		}
		
		#endregion
		
		#region DscDataSourceProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="DscDataSource"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static DscDataSourceProviderBase DscDataSourceProvider
		{
			get 
			{
				LoadProviders();
				return _provider.DscDataSourceProvider;
			}
		}
		
		#endregion
		
		#region PipeConflictProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PipeConflict"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PipeConflictProviderBase PipeConflictProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PipeConflictProvider;
			}
		}
		
		#endregion
		
		#region GrowthStateProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="GrowthState"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static GrowthStateProviderBase GrowthStateProvider
		{
			get 
			{
				LoadProviders();
				return _provider.GrowthStateProvider;
			}
		}
		
		#endregion
		
		#region PumpProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Pump"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PumpProviderBase PumpProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PumpProvider;
			}
		}
		
		#endregion
		
		#region IcTargetDifficultyProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="IcTargetDifficulty"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static IcTargetDifficultyProviderBase IcTargetDifficultyProvider
		{
			get 
			{
				LoadProviders();
				return _provider.IcTargetDifficultyProvider;
			}
		}
		
		#endregion
		
		#region PumpTypeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PumpType"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PumpTypeProviderBase PumpTypeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PumpTypeProvider;
			}
		}
		
		#endregion
		
		#region FixedFloorElevationProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="FixedFloorElevation"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static FixedFloorElevationProviderBase FixedFloorElevationProvider
		{
			get 
			{
				LoadProviders();
				return _provider.FixedFloorElevationProvider;
			}
		}
		
		#endregion
		
		#region LayerFileProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="LayerFile"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static LayerFileProviderBase LayerFileProvider
		{
			get 
			{
				LoadProviders();
				return _provider.LayerFileProvider;
			}
		}
		
		#endregion
		
		#region DscZingerProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="DscZinger"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static DscZingerProviderBase DscZingerProvider
		{
			get 
			{
				LoadProviders();
				return _provider.DscZingerProvider;
			}
		}
		
		#endregion
		
		#region IcTargetConstructedStatusProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="IcTargetConstructedStatus"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static IcTargetConstructedStatusProviderBase IcTargetConstructedStatusProvider
		{
			get 
			{
				LoadProviders();
				return _provider.IcTargetConstructedStatusProvider;
			}
		}
		
		#endregion
		
		#region IcDrywellProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="IcDrywell"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static IcDrywellProviderBase IcDrywellProvider
		{
			get 
			{
				LoadProviders();
				return _provider.IcDrywellProvider;
			}
		}
		
		#endregion
		
		#region CrossSectionProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="CrossSection"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static CrossSectionProviderBase CrossSectionProvider
		{
			get 
			{
				LoadProviders();
				return _provider.CrossSectionProvider;
			}
		}
		
		#endregion
		
		#region IcNodeRedirectorProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="IcNodeRedirector"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static IcNodeRedirectorProviderBase IcNodeRedirectorProvider
		{
			get 
			{
				LoadProviders();
				return _provider.IcNodeRedirectorProvider;
			}
		}
		
		#endregion
		
		#region PlacementTypeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PlacementType"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PlacementTypeProviderBase PlacementTypeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PlacementTypeProvider;
			}
		}
		
		#endregion
		
		#region CrossSectionDatumProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="CrossSectionDatum"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static CrossSectionDatumProviderBase CrossSectionDatumProvider
		{
			get 
			{
				LoadProviders();
				return _provider.CrossSectionDatumProvider;
			}
		}
		
		#endregion
		
		#region ParkingTargetProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ParkingTarget"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ParkingTargetProviderBase ParkingTargetProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ParkingTargetProvider;
			}
		}
		
		#endregion
		
		#region PipeShapeDatumProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PipeShapeDatum"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PipeShapeDatumProviderBase PipeShapeDatumProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PipeShapeDatumProvider;
			}
		}
		
		#endregion
		
		#region OrificeShapeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="OrificeShape"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static OrificeShapeProviderBase OrificeShapeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.OrificeShapeProvider;
			}
		}
		
		#endregion
		
		#region IcDiscoProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="IcDisco"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static IcDiscoProviderBase IcDiscoProvider
		{
			get 
			{
				LoadProviders();
				return _provider.IcDiscoProvider;
			}
		}
		
		#endregion
		
		#region OrificeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Orifice"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static OrificeProviderBase OrificeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.OrificeProvider;
			}
		}
		
		#endregion
		
		#region ASequenceProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ASequence"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ASequenceProviderBase ASequenceProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ASequenceProvider;
			}
		}
		
		#endregion
		
		#region SscZingerProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SscZinger"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SscZingerProviderBase SscZingerProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SscZingerProvider;
			}
		}
		
		#endregion
		
		
		#endregion
	}
	
	#region Query/Filters
		
	#region OrificeTypeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="OrificeType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OrificeTypeFilters : OrificeTypeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OrificeTypeFilters class.
		/// </summary>
		public OrificeTypeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the OrificeTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OrificeTypeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OrificeTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OrificeTypeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OrificeTypeFilters
	
	#region OrificeTypeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="OrificeTypeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="OrificeType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OrificeTypeQuery : OrificeTypeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OrificeTypeQuery class.
		/// </summary>
		public OrificeTypeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the OrificeTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OrificeTypeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OrificeTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OrificeTypeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OrificeTypeQuery
		
	#region PipeShapeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PipeShape"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PipeShapeFilters : PipeShapeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PipeShapeFilters class.
		/// </summary>
		public PipeShapeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PipeShapeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PipeShapeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PipeShapeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PipeShapeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PipeShapeFilters
	
	#region PipeShapeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PipeShapeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PipeShape"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PipeShapeQuery : PipeShapeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PipeShapeQuery class.
		/// </summary>
		public PipeShapeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PipeShapeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PipeShapeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PipeShapeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PipeShapeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PipeShapeQuery
		
	#region StreetTargetTypeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="StreetTargetType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StreetTargetTypeFilters : StreetTargetTypeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StreetTargetTypeFilters class.
		/// </summary>
		public StreetTargetTypeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the StreetTargetTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StreetTargetTypeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StreetTargetTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StreetTargetTypeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StreetTargetTypeFilters
	
	#region StreetTargetTypeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="StreetTargetTypeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="StreetTargetType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StreetTargetTypeQuery : StreetTargetTypeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StreetTargetTypeQuery class.
		/// </summary>
		public StreetTargetTypeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the StreetTargetTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StreetTargetTypeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StreetTargetTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StreetTargetTypeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StreetTargetTypeQuery
		
	#region ZoneFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Zone"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ZoneFilters : ZoneFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ZoneFilters class.
		/// </summary>
		public ZoneFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ZoneFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ZoneFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ZoneFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ZoneFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ZoneFilters
	
	#region ZoneQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ZoneParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Zone"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ZoneQuery : ZoneParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ZoneQuery class.
		/// </summary>
		public ZoneQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ZoneQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ZoneQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ZoneQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ZoneQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ZoneQuery
		
	#region StatusFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Status"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StatusFilters : StatusFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StatusFilters class.
		/// </summary>
		public StatusFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the StatusFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StatusFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StatusFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StatusFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StatusFilters
	
	#region StatusQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="StatusParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Status"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StatusQuery : StatusParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StatusQuery class.
		/// </summary>
		public StatusQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the StatusQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StatusQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StatusQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StatusQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StatusQuery
		
	#region LinkTypeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="LinkType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class LinkTypeFilters : LinkTypeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the LinkTypeFilters class.
		/// </summary>
		public LinkTypeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the LinkTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public LinkTypeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the LinkTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public LinkTypeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion LinkTypeFilters
	
	#region LinkTypeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="LinkTypeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="LinkType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class LinkTypeQuery : LinkTypeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the LinkTypeQuery class.
		/// </summary>
		public LinkTypeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the LinkTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public LinkTypeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the LinkTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public LinkTypeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion LinkTypeQuery
		
	#region SscFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Ssc"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SscFilters : SscFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SscFilters class.
		/// </summary>
		public SscFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SscFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SscFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SscFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SscFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SscFilters
	
	#region SscQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SscParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Ssc"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SscQuery : SscParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SscQuery class.
		/// </summary>
		public SscQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SscQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SscQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SscQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SscQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SscQuery
		
	#region PipeFlowTypeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PipeFlowType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PipeFlowTypeFilters : PipeFlowTypeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PipeFlowTypeFilters class.
		/// </summary>
		public PipeFlowTypeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PipeFlowTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PipeFlowTypeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PipeFlowTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PipeFlowTypeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PipeFlowTypeFilters
	
	#region PipeFlowTypeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PipeFlowTypeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PipeFlowType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PipeFlowTypeQuery : PipeFlowTypeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PipeFlowTypeQuery class.
		/// </summary>
		public PipeFlowTypeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PipeFlowTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PipeFlowTypeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PipeFlowTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PipeFlowTypeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PipeFlowTypeQuery
		
	#region WeirTypeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="WeirType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class WeirTypeFilters : WeirTypeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the WeirTypeFilters class.
		/// </summary>
		public WeirTypeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the WeirTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public WeirTypeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the WeirTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public WeirTypeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion WeirTypeFilters
	
	#region WeirTypeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="WeirTypeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="WeirType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class WeirTypeQuery : WeirTypeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the WeirTypeQuery class.
		/// </summary>
		public WeirTypeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the WeirTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public WeirTypeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the WeirTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public WeirTypeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion WeirTypeQuery
		
	#region SpecialLinkDatumFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SpecialLinkDatum"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SpecialLinkDatumFilters : SpecialLinkDatumFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SpecialLinkDatumFilters class.
		/// </summary>
		public SpecialLinkDatumFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SpecialLinkDatumFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SpecialLinkDatumFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SpecialLinkDatumFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SpecialLinkDatumFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SpecialLinkDatumFilters
	
	#region SpecialLinkDatumQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SpecialLinkDatumParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SpecialLinkDatum"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SpecialLinkDatumQuery : SpecialLinkDatumParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SpecialLinkDatumQuery class.
		/// </summary>
		public SpecialLinkDatumQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SpecialLinkDatumQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SpecialLinkDatumQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SpecialLinkDatumQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SpecialLinkDatumQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SpecialLinkDatumQuery
		
	#region SpecialLinkTypeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SpecialLinkType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SpecialLinkTypeFilters : SpecialLinkTypeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SpecialLinkTypeFilters class.
		/// </summary>
		public SpecialLinkTypeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SpecialLinkTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SpecialLinkTypeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SpecialLinkTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SpecialLinkTypeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SpecialLinkTypeFilters
	
	#region SpecialLinkTypeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SpecialLinkTypeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SpecialLinkType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SpecialLinkTypeQuery : SpecialLinkTypeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SpecialLinkTypeQuery class.
		/// </summary>
		public SpecialLinkTypeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SpecialLinkTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SpecialLinkTypeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SpecialLinkTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SpecialLinkTypeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SpecialLinkTypeQuery
		
	#region RoofTargetFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="RoofTarget"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class RoofTargetFilters : RoofTargetFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the RoofTargetFilters class.
		/// </summary>
		public RoofTargetFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the RoofTargetFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public RoofTargetFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the RoofTargetFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public RoofTargetFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion RoofTargetFilters
	
	#region RoofTargetQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="RoofTargetParameterBuilder"/> class
	/// that is used exclusively with a <see cref="RoofTarget"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class RoofTargetQuery : RoofTargetParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the RoofTargetQuery class.
		/// </summary>
		public RoofTargetQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the RoofTargetQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public RoofTargetQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the RoofTargetQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public RoofTargetQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion RoofTargetQuery
		
	#region DscFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Dsc"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DscFilters : DscFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DscFilters class.
		/// </summary>
		public DscFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the DscFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DscFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DscFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DscFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DscFilters
	
	#region DscQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="DscParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Dsc"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DscQuery : DscParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DscQuery class.
		/// </summary>
		public DscQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the DscQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DscQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DscQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DscQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DscQuery
		
	#region SewerabilityFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Sewerability"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SewerabilityFilters : SewerabilityFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SewerabilityFilters class.
		/// </summary>
		public SewerabilityFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SewerabilityFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SewerabilityFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SewerabilityFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SewerabilityFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SewerabilityFilters
	
	#region SewerabilityQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SewerabilityParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Sewerability"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SewerabilityQuery : SewerabilityParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SewerabilityQuery class.
		/// </summary>
		public SewerabilityQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SewerabilityQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SewerabilityQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SewerabilityQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SewerabilityQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SewerabilityQuery
		
	#region PumpCurveFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PumpCurve"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PumpCurveFilters : PumpCurveFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PumpCurveFilters class.
		/// </summary>
		public PumpCurveFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PumpCurveFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PumpCurveFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PumpCurveFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PumpCurveFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PumpCurveFilters
	
	#region PumpCurveQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PumpCurveParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PumpCurve"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PumpCurveQuery : PumpCurveParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PumpCurveQuery class.
		/// </summary>
		public PumpCurveQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PumpCurveQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PumpCurveQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PumpCurveQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PumpCurveQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PumpCurveQuery
		
	#region SpecialLinkFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SpecialLink"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SpecialLinkFilters : SpecialLinkFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SpecialLinkFilters class.
		/// </summary>
		public SpecialLinkFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SpecialLinkFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SpecialLinkFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SpecialLinkFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SpecialLinkFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SpecialLinkFilters
	
	#region SpecialLinkQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SpecialLinkParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SpecialLink"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SpecialLinkQuery : SpecialLinkParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SpecialLinkQuery class.
		/// </summary>
		public SpecialLinkQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SpecialLinkQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SpecialLinkQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SpecialLinkQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SpecialLinkQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SpecialLinkQuery
		
	#region SanPatternFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SanPattern"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SanPatternFilters : SanPatternFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SanPatternFilters class.
		/// </summary>
		public SanPatternFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SanPatternFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SanPatternFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SanPatternFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SanPatternFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SanPatternFilters
	
	#region SanPatternQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SanPatternParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SanPattern"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SanPatternQuery : SanPatternParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SanPatternQuery class.
		/// </summary>
		public SanPatternQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SanPatternQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SanPatternQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SanPatternQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SanPatternQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SanPatternQuery
		
	#region StormTypeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="StormType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StormTypeFilters : StormTypeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StormTypeFilters class.
		/// </summary>
		public StormTypeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the StormTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StormTypeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StormTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StormTypeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StormTypeFilters
	
	#region StormTypeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="StormTypeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="StormType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StormTypeQuery : StormTypeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StormTypeQuery class.
		/// </summary>
		public StormTypeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the StormTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StormTypeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StormTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StormTypeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StormTypeQuery
		
	#region TimeFrameFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="TimeFrame"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TimeFrameFilters : TimeFrameFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TimeFrameFilters class.
		/// </summary>
		public TimeFrameFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the TimeFrameFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TimeFrameFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TimeFrameFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TimeFrameFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TimeFrameFilters
	
	#region TimeFrameQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="TimeFrameParameterBuilder"/> class
	/// that is used exclusively with a <see cref="TimeFrame"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TimeFrameQuery : TimeFrameParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TimeFrameQuery class.
		/// </summary>
		public TimeFrameQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the TimeFrameQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TimeFrameQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TimeFrameQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TimeFrameQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TimeFrameQuery
		
	#region NodeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Node"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NodeFilters : NodeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NodeFilters class.
		/// </summary>
		public NodeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NodeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NodeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NodeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NodeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NodeFilters
	
	#region NodeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NodeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Node"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NodeQuery : NodeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NodeQuery class.
		/// </summary>
		public NodeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NodeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NodeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NodeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NodeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NodeQuery
		
	#region StormFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Storm"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StormFilters : StormFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StormFilters class.
		/// </summary>
		public StormFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the StormFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StormFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StormFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StormFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StormFilters
	
	#region StormQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="StormParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Storm"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StormQuery : StormParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StormQuery class.
		/// </summary>
		public StormQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the StormQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StormQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StormQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StormQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StormQuery
		
	#region WeirFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Weir"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class WeirFilters : WeirFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the WeirFilters class.
		/// </summary>
		public WeirFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the WeirFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public WeirFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the WeirFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public WeirFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion WeirFilters
	
	#region WeirQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="WeirParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Weir"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class WeirQuery : WeirParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the WeirQuery class.
		/// </summary>
		public WeirQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the WeirQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public WeirQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the WeirQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public WeirQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion WeirQuery
		
	#region AsmZoningFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="AsmZoning"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AsmZoningFilters : AsmZoningFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AsmZoningFilters class.
		/// </summary>
		public AsmZoningFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the AsmZoningFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AsmZoningFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AsmZoningFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AsmZoningFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AsmZoningFilters
	
	#region AsmZoningQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="AsmZoningParameterBuilder"/> class
	/// that is used exclusively with a <see cref="AsmZoning"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AsmZoningQuery : AsmZoningParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AsmZoningQuery class.
		/// </summary>
		public AsmZoningQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the AsmZoningQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AsmZoningQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AsmZoningQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AsmZoningQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AsmZoningQuery
		
	#region DataSourceFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="DataSource"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DataSourceFilters : DataSourceFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DataSourceFilters class.
		/// </summary>
		public DataSourceFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the DataSourceFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DataSourceFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DataSourceFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DataSourceFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DataSourceFilters
	
	#region DataSourceQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="DataSourceParameterBuilder"/> class
	/// that is used exclusively with a <see cref="DataSource"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DataSourceQuery : DataSourceParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DataSourceQuery class.
		/// </summary>
		public DataSourceQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the DataSourceQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DataSourceQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DataSourceQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DataSourceQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DataSourceQuery
		
	#region AssumptionCodeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="AssumptionCode"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AssumptionCodeFilters : AssumptionCodeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AssumptionCodeFilters class.
		/// </summary>
		public AssumptionCodeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the AssumptionCodeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AssumptionCodeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AssumptionCodeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AssumptionCodeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AssumptionCodeFilters
	
	#region AssumptionCodeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="AssumptionCodeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="AssumptionCode"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AssumptionCodeQuery : AssumptionCodeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AssumptionCodeQuery class.
		/// </summary>
		public AssumptionCodeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the AssumptionCodeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AssumptionCodeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AssumptionCodeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AssumptionCodeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AssumptionCodeQuery
		
	#region HansenServiceCodeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="HansenServiceCode"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class HansenServiceCodeFilters : HansenServiceCodeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the HansenServiceCodeFilters class.
		/// </summary>
		public HansenServiceCodeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the HansenServiceCodeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public HansenServiceCodeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the HansenServiceCodeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public HansenServiceCodeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion HansenServiceCodeFilters
	
	#region HansenServiceCodeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="HansenServiceCodeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="HansenServiceCode"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class HansenServiceCodeQuery : HansenServiceCodeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the HansenServiceCodeQuery class.
		/// </summary>
		public HansenServiceCodeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the HansenServiceCodeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public HansenServiceCodeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the HansenServiceCodeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public HansenServiceCodeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion HansenServiceCodeQuery
		
	#region NodeTypeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="NodeType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NodeTypeFilters : NodeTypeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NodeTypeFilters class.
		/// </summary>
		public NodeTypeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NodeTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NodeTypeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NodeTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NodeTypeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NodeTypeFilters
	
	#region NodeTypeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NodeTypeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="NodeType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NodeTypeQuery : NodeTypeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NodeTypeQuery class.
		/// </summary>
		public NodeTypeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NodeTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NodeTypeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NodeTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NodeTypeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NodeTypeQuery
		
	#region MaterialFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Material"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class MaterialFilters : MaterialFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the MaterialFilters class.
		/// </summary>
		public MaterialFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the MaterialFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public MaterialFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the MaterialFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public MaterialFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion MaterialFilters
	
	#region MaterialQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="MaterialParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Material"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class MaterialQuery : MaterialParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the MaterialQuery class.
		/// </summary>
		public MaterialQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the MaterialQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public MaterialQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the MaterialQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public MaterialQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion MaterialQuery
		
	#region DiscoClassFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="DiscoClass"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DiscoClassFilters : DiscoClassFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DiscoClassFilters class.
		/// </summary>
		public DiscoClassFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the DiscoClassFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DiscoClassFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DiscoClassFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DiscoClassFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DiscoClassFilters
	
	#region DiscoClassQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="DiscoClassParameterBuilder"/> class
	/// that is used exclusively with a <see cref="DiscoClass"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DiscoClassQuery : DiscoClassParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DiscoClassQuery class.
		/// </summary>
		public DiscoClassQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the DiscoClassQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DiscoClassQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DiscoClassQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DiscoClassQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DiscoClassQuery
		
	#region StreetTargetFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="StreetTarget"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StreetTargetFilters : StreetTargetFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StreetTargetFilters class.
		/// </summary>
		public StreetTargetFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the StreetTargetFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StreetTargetFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StreetTargetFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StreetTargetFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StreetTargetFilters
	
	#region StreetTargetQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="StreetTargetParameterBuilder"/> class
	/// that is used exclusively with a <see cref="StreetTarget"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StreetTargetQuery : StreetTargetParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StreetTargetQuery class.
		/// </summary>
		public StreetTargetQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the StreetTargetQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StreetTargetQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StreetTargetQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StreetTargetQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StreetTargetQuery
		
	#region ImperviousTypeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ImperviousType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ImperviousTypeFilters : ImperviousTypeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ImperviousTypeFilters class.
		/// </summary>
		public ImperviousTypeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ImperviousTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ImperviousTypeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ImperviousTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ImperviousTypeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ImperviousTypeFilters
	
	#region ImperviousTypeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ImperviousTypeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ImperviousType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ImperviousTypeQuery : ImperviousTypeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ImperviousTypeQuery class.
		/// </summary>
		public ImperviousTypeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ImperviousTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ImperviousTypeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ImperviousTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ImperviousTypeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ImperviousTypeQuery
		
	#region DetailedZoneFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="DetailedZone"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DetailedZoneFilters : DetailedZoneFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DetailedZoneFilters class.
		/// </summary>
		public DetailedZoneFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the DetailedZoneFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DetailedZoneFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DetailedZoneFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DetailedZoneFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DetailedZoneFilters
	
	#region DetailedZoneQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="DetailedZoneParameterBuilder"/> class
	/// that is used exclusively with a <see cref="DetailedZone"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DetailedZoneQuery : DetailedZoneParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DetailedZoneQuery class.
		/// </summary>
		public DetailedZoneQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the DetailedZoneQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DetailedZoneQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DetailedZoneQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DetailedZoneQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DetailedZoneQuery
		
	#region LinkFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Link"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class LinkFilters : LinkFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the LinkFilters class.
		/// </summary>
		public LinkFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the LinkFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public LinkFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the LinkFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public LinkFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion LinkFilters
	
	#region LinkQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="LinkParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Link"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class LinkQuery : LinkParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the LinkQuery class.
		/// </summary>
		public LinkQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the LinkQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public LinkQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the LinkQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public LinkQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion LinkQuery
		
	#region DscDataSourceFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="DscDataSource"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DscDataSourceFilters : DscDataSourceFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DscDataSourceFilters class.
		/// </summary>
		public DscDataSourceFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the DscDataSourceFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DscDataSourceFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DscDataSourceFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DscDataSourceFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DscDataSourceFilters
	
	#region DscDataSourceQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="DscDataSourceParameterBuilder"/> class
	/// that is used exclusively with a <see cref="DscDataSource"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DscDataSourceQuery : DscDataSourceParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DscDataSourceQuery class.
		/// </summary>
		public DscDataSourceQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the DscDataSourceQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DscDataSourceQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DscDataSourceQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DscDataSourceQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DscDataSourceQuery
		
	#region PipeConflictFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PipeConflict"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PipeConflictFilters : PipeConflictFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PipeConflictFilters class.
		/// </summary>
		public PipeConflictFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PipeConflictFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PipeConflictFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PipeConflictFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PipeConflictFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PipeConflictFilters
	
	#region PipeConflictQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PipeConflictParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PipeConflict"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PipeConflictQuery : PipeConflictParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PipeConflictQuery class.
		/// </summary>
		public PipeConflictQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PipeConflictQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PipeConflictQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PipeConflictQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PipeConflictQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PipeConflictQuery
		
	#region GrowthStateFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="GrowthState"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GrowthStateFilters : GrowthStateFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GrowthStateFilters class.
		/// </summary>
		public GrowthStateFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the GrowthStateFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GrowthStateFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GrowthStateFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GrowthStateFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GrowthStateFilters
	
	#region GrowthStateQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="GrowthStateParameterBuilder"/> class
	/// that is used exclusively with a <see cref="GrowthState"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GrowthStateQuery : GrowthStateParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GrowthStateQuery class.
		/// </summary>
		public GrowthStateQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the GrowthStateQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GrowthStateQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GrowthStateQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GrowthStateQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GrowthStateQuery
		
	#region PumpFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Pump"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PumpFilters : PumpFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PumpFilters class.
		/// </summary>
		public PumpFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PumpFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PumpFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PumpFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PumpFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PumpFilters
	
	#region PumpQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PumpParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Pump"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PumpQuery : PumpParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PumpQuery class.
		/// </summary>
		public PumpQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PumpQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PumpQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PumpQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PumpQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PumpQuery
		
	#region IcTargetDifficultyFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="IcTargetDifficulty"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class IcTargetDifficultyFilters : IcTargetDifficultyFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the IcTargetDifficultyFilters class.
		/// </summary>
		public IcTargetDifficultyFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the IcTargetDifficultyFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public IcTargetDifficultyFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the IcTargetDifficultyFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public IcTargetDifficultyFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion IcTargetDifficultyFilters
	
	#region IcTargetDifficultyQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="IcTargetDifficultyParameterBuilder"/> class
	/// that is used exclusively with a <see cref="IcTargetDifficulty"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class IcTargetDifficultyQuery : IcTargetDifficultyParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the IcTargetDifficultyQuery class.
		/// </summary>
		public IcTargetDifficultyQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the IcTargetDifficultyQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public IcTargetDifficultyQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the IcTargetDifficultyQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public IcTargetDifficultyQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion IcTargetDifficultyQuery
		
	#region PumpTypeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PumpType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PumpTypeFilters : PumpTypeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PumpTypeFilters class.
		/// </summary>
		public PumpTypeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PumpTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PumpTypeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PumpTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PumpTypeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PumpTypeFilters
	
	#region PumpTypeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PumpTypeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PumpType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PumpTypeQuery : PumpTypeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PumpTypeQuery class.
		/// </summary>
		public PumpTypeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PumpTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PumpTypeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PumpTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PumpTypeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PumpTypeQuery
		
	#region FixedFloorElevationFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="FixedFloorElevation"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class FixedFloorElevationFilters : FixedFloorElevationFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the FixedFloorElevationFilters class.
		/// </summary>
		public FixedFloorElevationFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the FixedFloorElevationFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public FixedFloorElevationFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the FixedFloorElevationFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public FixedFloorElevationFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion FixedFloorElevationFilters
	
	#region FixedFloorElevationQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="FixedFloorElevationParameterBuilder"/> class
	/// that is used exclusively with a <see cref="FixedFloorElevation"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class FixedFloorElevationQuery : FixedFloorElevationParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the FixedFloorElevationQuery class.
		/// </summary>
		public FixedFloorElevationQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the FixedFloorElevationQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public FixedFloorElevationQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the FixedFloorElevationQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public FixedFloorElevationQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion FixedFloorElevationQuery
		
	#region LayerFileFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="LayerFile"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class LayerFileFilters : LayerFileFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the LayerFileFilters class.
		/// </summary>
		public LayerFileFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the LayerFileFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public LayerFileFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the LayerFileFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public LayerFileFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion LayerFileFilters
	
	#region LayerFileQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="LayerFileParameterBuilder"/> class
	/// that is used exclusively with a <see cref="LayerFile"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class LayerFileQuery : LayerFileParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the LayerFileQuery class.
		/// </summary>
		public LayerFileQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the LayerFileQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public LayerFileQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the LayerFileQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public LayerFileQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion LayerFileQuery
		
	#region DscZingerFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="DscZinger"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DscZingerFilters : DscZingerFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DscZingerFilters class.
		/// </summary>
		public DscZingerFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the DscZingerFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DscZingerFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DscZingerFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DscZingerFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DscZingerFilters
	
	#region DscZingerQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="DscZingerParameterBuilder"/> class
	/// that is used exclusively with a <see cref="DscZinger"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DscZingerQuery : DscZingerParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DscZingerQuery class.
		/// </summary>
		public DscZingerQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the DscZingerQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DscZingerQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DscZingerQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DscZingerQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DscZingerQuery
		
	#region IcTargetConstructedStatusFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="IcTargetConstructedStatus"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class IcTargetConstructedStatusFilters : IcTargetConstructedStatusFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the IcTargetConstructedStatusFilters class.
		/// </summary>
		public IcTargetConstructedStatusFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the IcTargetConstructedStatusFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public IcTargetConstructedStatusFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the IcTargetConstructedStatusFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public IcTargetConstructedStatusFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion IcTargetConstructedStatusFilters
	
	#region IcTargetConstructedStatusQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="IcTargetConstructedStatusParameterBuilder"/> class
	/// that is used exclusively with a <see cref="IcTargetConstructedStatus"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class IcTargetConstructedStatusQuery : IcTargetConstructedStatusParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the IcTargetConstructedStatusQuery class.
		/// </summary>
		public IcTargetConstructedStatusQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the IcTargetConstructedStatusQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public IcTargetConstructedStatusQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the IcTargetConstructedStatusQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public IcTargetConstructedStatusQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion IcTargetConstructedStatusQuery
		
	#region IcDrywellFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="IcDrywell"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class IcDrywellFilters : IcDrywellFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the IcDrywellFilters class.
		/// </summary>
		public IcDrywellFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the IcDrywellFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public IcDrywellFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the IcDrywellFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public IcDrywellFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion IcDrywellFilters
	
	#region IcDrywellQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="IcDrywellParameterBuilder"/> class
	/// that is used exclusively with a <see cref="IcDrywell"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class IcDrywellQuery : IcDrywellParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the IcDrywellQuery class.
		/// </summary>
		public IcDrywellQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the IcDrywellQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public IcDrywellQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the IcDrywellQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public IcDrywellQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion IcDrywellQuery
		
	#region CrossSectionFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="CrossSection"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CrossSectionFilters : CrossSectionFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CrossSectionFilters class.
		/// </summary>
		public CrossSectionFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the CrossSectionFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CrossSectionFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CrossSectionFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CrossSectionFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CrossSectionFilters
	
	#region CrossSectionQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="CrossSectionParameterBuilder"/> class
	/// that is used exclusively with a <see cref="CrossSection"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CrossSectionQuery : CrossSectionParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CrossSectionQuery class.
		/// </summary>
		public CrossSectionQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the CrossSectionQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CrossSectionQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CrossSectionQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CrossSectionQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CrossSectionQuery
		
	#region IcNodeRedirectorFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="IcNodeRedirector"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class IcNodeRedirectorFilters : IcNodeRedirectorFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the IcNodeRedirectorFilters class.
		/// </summary>
		public IcNodeRedirectorFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the IcNodeRedirectorFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public IcNodeRedirectorFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the IcNodeRedirectorFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public IcNodeRedirectorFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion IcNodeRedirectorFilters
	
	#region IcNodeRedirectorQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="IcNodeRedirectorParameterBuilder"/> class
	/// that is used exclusively with a <see cref="IcNodeRedirector"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class IcNodeRedirectorQuery : IcNodeRedirectorParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the IcNodeRedirectorQuery class.
		/// </summary>
		public IcNodeRedirectorQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the IcNodeRedirectorQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public IcNodeRedirectorQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the IcNodeRedirectorQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public IcNodeRedirectorQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion IcNodeRedirectorQuery
		
	#region PlacementTypeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PlacementType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PlacementTypeFilters : PlacementTypeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PlacementTypeFilters class.
		/// </summary>
		public PlacementTypeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PlacementTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PlacementTypeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PlacementTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PlacementTypeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PlacementTypeFilters
	
	#region PlacementTypeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PlacementTypeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PlacementType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PlacementTypeQuery : PlacementTypeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PlacementTypeQuery class.
		/// </summary>
		public PlacementTypeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PlacementTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PlacementTypeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PlacementTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PlacementTypeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PlacementTypeQuery
		
	#region CrossSectionDatumFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="CrossSectionDatum"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CrossSectionDatumFilters : CrossSectionDatumFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CrossSectionDatumFilters class.
		/// </summary>
		public CrossSectionDatumFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the CrossSectionDatumFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CrossSectionDatumFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CrossSectionDatumFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CrossSectionDatumFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CrossSectionDatumFilters
	
	#region CrossSectionDatumQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="CrossSectionDatumParameterBuilder"/> class
	/// that is used exclusively with a <see cref="CrossSectionDatum"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CrossSectionDatumQuery : CrossSectionDatumParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CrossSectionDatumQuery class.
		/// </summary>
		public CrossSectionDatumQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the CrossSectionDatumQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CrossSectionDatumQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CrossSectionDatumQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CrossSectionDatumQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CrossSectionDatumQuery
		
	#region ParkingTargetFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ParkingTarget"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ParkingTargetFilters : ParkingTargetFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ParkingTargetFilters class.
		/// </summary>
		public ParkingTargetFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ParkingTargetFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ParkingTargetFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ParkingTargetFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ParkingTargetFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ParkingTargetFilters
	
	#region ParkingTargetQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ParkingTargetParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ParkingTarget"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ParkingTargetQuery : ParkingTargetParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ParkingTargetQuery class.
		/// </summary>
		public ParkingTargetQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ParkingTargetQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ParkingTargetQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ParkingTargetQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ParkingTargetQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ParkingTargetQuery
		
	#region PipeShapeDatumFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PipeShapeDatum"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PipeShapeDatumFilters : PipeShapeDatumFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PipeShapeDatumFilters class.
		/// </summary>
		public PipeShapeDatumFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PipeShapeDatumFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PipeShapeDatumFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PipeShapeDatumFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PipeShapeDatumFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PipeShapeDatumFilters
	
	#region PipeShapeDatumQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PipeShapeDatumParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PipeShapeDatum"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PipeShapeDatumQuery : PipeShapeDatumParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PipeShapeDatumQuery class.
		/// </summary>
		public PipeShapeDatumQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PipeShapeDatumQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PipeShapeDatumQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PipeShapeDatumQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PipeShapeDatumQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PipeShapeDatumQuery
		
	#region OrificeShapeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="OrificeShape"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OrificeShapeFilters : OrificeShapeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OrificeShapeFilters class.
		/// </summary>
		public OrificeShapeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the OrificeShapeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OrificeShapeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OrificeShapeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OrificeShapeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OrificeShapeFilters
	
	#region OrificeShapeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="OrificeShapeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="OrificeShape"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OrificeShapeQuery : OrificeShapeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OrificeShapeQuery class.
		/// </summary>
		public OrificeShapeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the OrificeShapeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OrificeShapeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OrificeShapeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OrificeShapeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OrificeShapeQuery
		
	#region IcDiscoFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="IcDisco"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class IcDiscoFilters : IcDiscoFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the IcDiscoFilters class.
		/// </summary>
		public IcDiscoFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the IcDiscoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public IcDiscoFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the IcDiscoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public IcDiscoFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion IcDiscoFilters
	
	#region IcDiscoQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="IcDiscoParameterBuilder"/> class
	/// that is used exclusively with a <see cref="IcDisco"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class IcDiscoQuery : IcDiscoParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the IcDiscoQuery class.
		/// </summary>
		public IcDiscoQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the IcDiscoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public IcDiscoQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the IcDiscoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public IcDiscoQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion IcDiscoQuery
		
	#region OrificeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Orifice"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OrificeFilters : OrificeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OrificeFilters class.
		/// </summary>
		public OrificeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the OrificeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OrificeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OrificeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OrificeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OrificeFilters
	
	#region OrificeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="OrificeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Orifice"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OrificeQuery : OrificeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OrificeQuery class.
		/// </summary>
		public OrificeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the OrificeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OrificeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OrificeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OrificeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OrificeQuery
		
	#region ASequenceFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ASequence"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ASequenceFilters : ASequenceFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ASequenceFilters class.
		/// </summary>
		public ASequenceFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ASequenceFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ASequenceFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ASequenceFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ASequenceFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ASequenceFilters
	
	#region ASequenceQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ASequenceParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ASequence"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ASequenceQuery : ASequenceParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ASequenceQuery class.
		/// </summary>
		public ASequenceQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ASequenceQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ASequenceQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ASequenceQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ASequenceQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ASequenceQuery
		
	#region SscZingerFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SscZinger"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SscZingerFilters : SscZingerFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SscZingerFilters class.
		/// </summary>
		public SscZingerFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SscZingerFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SscZingerFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SscZingerFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SscZingerFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SscZingerFilters
	
	#region SscZingerQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SscZingerParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SscZinger"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SscZingerQuery : SscZingerParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SscZingerQuery class.
		/// </summary>
		public SscZingerQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SscZingerQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SscZingerQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SscZingerQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SscZingerQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SscZingerQuery
	#endregion

	
}
